﻿namespace Example
{
    using Xunit;

    public sealed class DollarFacts
    {
        [Fact]
        public void ctor_decimal()
        {
            Assert.NotNull(new Dollar(0m));
        }

        [Fact]
        public void ctor_int()
        {
            Assert.NotNull(new Dollar(0));
        }

        [Fact]
        public void op_ToString()
        {
            const string expected = "zero";
            var actual = new Dollar(0).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when1()
        {
            const string expected = "one";
            var actual = new Dollar(1).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when10()
        {
            const string expected = "ten";
            var actual = new Dollar(10).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when11()
        {
            const string expected = "eleven";
            var actual = new Dollar(11).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when12()
        {
            const string expected = "twelve";
            var actual = new Dollar(12).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when13()
        {
            const string expected = "thirteen";
            var actual = new Dollar(13).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when14()
        {
            const string expected = "fourteen";
            var actual = new Dollar(14).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when15()
        {
            const string expected = "fifteen";
            var actual = new Dollar(15).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when16()
        {
            const string expected = "sixteen";
            var actual = new Dollar(16).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when17()
        {
            const string expected = "seventeen";
            var actual = new Dollar(17).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when18()
        {
            const string expected = "eighteen";
            var actual = new Dollar(18).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when19()
        {
            const string expected = "nineteen";
            var actual = new Dollar(19).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when1hundred9()
        {
            const string expected = "one hundred nine";
            var actual = new Dollar(109).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when2()
        {
            const string expected = "two";
            var actual = new Dollar(2).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when20()
        {
            const string expected = "twenty";
            var actual = new Dollar(20).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when28()
        {
            const string expected = "twenty-eight";
            var actual = new Dollar(28).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when2thousand1hundred9()
        {
            const string expected = "two thousand one hundred nine";
            var actual = new Dollar(2109).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when3()
        {
            const string expected = "three";
            var actual = new Dollar(3).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when30()
        {
            const string expected = "thirty";
            var actual = new Dollar(30).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when37()
        {
            const string expected = "thirty-seven";
            var actual = new Dollar(37).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when4()
        {
            const string expected = "four";
            var actual = new Dollar(4).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when40()
        {
            const string expected = "forty";
            var actual = new Dollar(40).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when46()
        {
            const string expected = "forty-six";
            var actual = new Dollar(46).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when5()
        {
            const string expected = "five";
            var actual = new Dollar(5).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when50()
        {
            const string expected = "fifty";
            var actual = new Dollar(50).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when55()
        {
            const string expected = "fifty-five";
            var actual = new Dollar(55).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when6()
        {
            const string expected = "six";
            var actual = new Dollar(6).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when60()
        {
            const string expected = "sixty";
            var actual = new Dollar(60).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when64()
        {
            const string expected = "sixty-four";
            var actual = new Dollar(64).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when7()
        {
            const string expected = "seven";
            var actual = new Dollar(7).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when70()
        {
            const string expected = "seventy";
            var actual = new Dollar(70).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when73()
        {
            const string expected = "seventy-three";
            var actual = new Dollar(73).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when8()
        {
            const string expected = "eight";
            var actual = new Dollar(8).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when80()
        {
            const string expected = "eighty";
            var actual = new Dollar(80).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when82()
        {
            const string expected = "eighty-two";
            var actual = new Dollar(82).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when9()
        {
            const string expected = "nine";
            var actual = new Dollar(9).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when90()
        {
            const string expected = "ninety";
            var actual = new Dollar(90).ToString();

            Assert.Equal(expected, actual);
        }

        [Fact]
        public void op_ToString_when91()
        {
            const string expected = "ninety-one";
            var actual = new Dollar(91).ToString();

            Assert.Equal(expected, actual);
        }
    }
}